• chore(engine): publish engine bases in ci #4649 : 3 dependent PRs (#4650 , #4652 , #4666 )
• chore: lockfile lefthook #4647
• fix(rivetkit): surface native sqlite kv errors to callers #4645
• fix(rivetkit): prevent sleep races during disconnect and db work #4644
• fix(rivetkit): isolate engine envoys and propagate startup failures #4643
• test(rivetkit): remove wasm sqlite-only fixtures and coverage #4642
• chore(sqlite-vfs): remove wasm sqlite packages and workspace wiring #4641
• chore(rivetkit): remove wasm sqlite runtime #4614
• fix(sqlite-native): restore native startup kv preload #4639
• fix(sqlite-native): delete metadata before chunk range #4638
• fix(sqlite-native): keep truncate cache coherent #4637
• fix(sqlite-vfs): use delete range for truncate cleanup #4636
• fix(sqlite-native): restore kv error hook #4635
• perf(sqlite-native): avoid cloning cached read chunks #4634
• perf(sqlite-native): gate kv operation labels #4633
• perf(sqlite-native): reuse read cache for partial writes #4632 👈 (View in Graphite)
• perf(sqlite-native): remove delete file existence probe #4631
• fix(sqlite-native): gate native read cache behind env var #4630
• fix(pegboard): isolate runner config dc lookup failures #4625 : 1 other dependent PR (#4626 )
• docs(pegboard): note runner config upsert split write risk #4624
• fix(pegboard): unpack global runner config keys correctly #4623
• fix(pegboard-gateway): enforce tunnel message state #4622
• fix(pegboard-runner): clear terminal tunnel routes #4621
• fix(pegboard): skip protocol version keys in runner pool backfill #4620
• fix(pegboard): create missing normal runner configs #4619
• fix(epoxy): reuse cached optimistic value #4618
• main

This stack of pull requests is managed by Graphite. Learn more about stacking.

PR Review: perf(sqlite-native): reuse read cache for partial writes

Overview

This PR optimizes the native SQLite VFS write path by consulting the read cache before issuing a KV round-trip for partial-chunk writes. When needs_existing is true and read_cache_enabled is set, the write planner now checks state.read_cache first and only adds the chunk to the KV fetch list on a cache miss. The approach is correct in principle — the read cache is already kept consistent (populated on reads, updated on writes, cleared on truncate) — so reusing it for writes avoids redundant KV round-trips.

Bug: Likely Compile Error

The cache lookup calls .get() directly on Option<HashMap<Vec<u8>, Vec<u8>>>:

let cached_chunk = if needs_existing && ctx.read_cache_enabled {
    let state = get_file_state(file.state);
    state.read_cache.get(chunk_key.as_slice()).cloned()  // compile error
} else {
    None
};

Option<T> has no get(key) method in Rust. The consistent pattern used everywhere else in this file (e.g. lines 431–434, 448–452, 672, 728) is to unwrap the Option first:

// Existing pattern throughout the file:
if let Some(read_cache) = state.read_cache.as_ref() {
    read_cache.get(key.as_slice())
}

// Correct form for the new one-liner:
state.read_cache.as_ref().and_then(|c| c.get(chunk_key.as_slice())).cloned()

The ctx.read_cache_enabled guard ensures the cache is Some at runtime, but Rust's type checker does not know that — this should fail to compile.

Pre-existing Concern: Cache Updated Before KV Write Succeeds

Lines 672–679 insert the new chunk data into the read cache before the KV put on line 683. If the KV write fails, the file size is rolled back (lines 684–686) but the cache retains the not-yet-persisted data. A subsequent partial write to the same chunk will now use the stale cached bytes as the "existing" base, potentially producing a corrupted page.

This is a pre-existing issue, but this PR extends its surface: previously, stale cache entries only affected reads; now they also gate whether KV is consulted during writes.

A simple fix: update the cache after confirming the KV put succeeded, or evict affected keys on write failure.

WASM VFS Parity

CLAUDE.md requires that the native Rust VFS and the WASM TypeScript VFS match 1:1. The WASM VFS (packages/sqlite-wasm/src/vfs.ts) does not appear to have the same read-cache infrastructure, so a direct port may not apply. However, the PR should explicitly note this gap and confirm that the behavioral contract is unchanged (same KV reads/writes, only the fetch elision differs).

Test Coverage

No tests are added for the cache-hit path during partial writes. A regression test asserting that KV fetch count is reduced when a chunk is already in the read cache would be valuable here, especially given the cache/KV ordering issue noted above.

Summary